home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2004 #2 / K-CD-2-2004.ISO / OpenOffice Sv / f_0397 / python-core-2.2.2 / lib / weakref.py < prev    next >
Encoding:
Python Source  |  2003-07-18  |  7.1 KB  |  285 lines
  1. """Weak reference support for Python.
  2.  
  3. This module is an implementation of PEP 205:
  4.  
  5. http://python.sourceforge.net/peps/pep-0205.html
  6. """
  7.  
  8. # Naming convention: Variables named "wr" are weak reference objects;
  9. # they are called this instead of "ref" to avoid name collisions with
  10. # the module-global ref() function imported from _weakref.
  11.  
  12. import UserDict
  13.  
  14. from _weakref import \
  15.      getweakrefcount, \
  16.      getweakrefs, \
  17.      ref, \
  18.      proxy, \
  19.      CallableProxyType, \
  20.      ProxyType, \
  21.      ReferenceType
  22.  
  23. from exceptions import ReferenceError
  24.  
  25.  
  26. ProxyTypes = (ProxyType, CallableProxyType)
  27.  
  28. __all__ = ["ref", "proxy", "getweakrefcount", "getweakrefs",
  29.            "WeakKeyDictionary", "ReferenceType", "ProxyType",
  30.            "CallableProxyType", "ProxyTypes", "WeakValueDictionary"]
  31.  
  32.  
  33. class WeakValueDictionary(UserDict.UserDict):
  34.     """Mapping class that references values weakly.
  35.  
  36.     Entries in the dictionary will be discarded when no strong
  37.     reference to the value exists anymore
  38.     """
  39.     # We inherit the constructor without worrying about the input
  40.     # dictionary; since it uses our .update() method, we get the right
  41.     # checks (if the other dictionary is a WeakValueDictionary,
  42.     # objects are unwrapped on the way out, and we always wrap on the
  43.     # way in).
  44.  
  45.     def __getitem__(self, key):
  46.         o = self.data[key]()
  47.         if o is None:
  48.             raise KeyError, key
  49.         else:
  50.             return o
  51.  
  52.     def __repr__(self):
  53.         return "<WeakValueDictionary at %s>" % id(self)
  54.  
  55.     def __setitem__(self, key, value):
  56.         self.data[key] = ref(value, self.__makeremove(key))
  57.  
  58.     def copy(self):
  59.         new = WeakValueDictionary()
  60.         for key, wr in self.data.items():
  61.             o = wr()
  62.             if o is not None:
  63.                 new[key] = o
  64.         return new
  65.  
  66.     def get(self, key, default=None):
  67.         try:
  68.             wr = self.data[key]
  69.         except KeyError:
  70.             return default
  71.         else:
  72.             o = wr()
  73.             if o is None:
  74.                 # This should only happen
  75.                 return default
  76.             else:
  77.                 return o
  78.  
  79.     def items(self):
  80.         L = []
  81.         for key, wr in self.data.items():
  82.             o = wr()
  83.             if o is not None:
  84.                 L.append((key, o))
  85.         return L
  86.  
  87.     def iteritems(self):
  88.         return WeakValuedItemIterator(self)
  89.  
  90.     def iterkeys(self):
  91.         return self.data.iterkeys()
  92.     __iter__ = iterkeys
  93.  
  94.     def itervalues(self):
  95.         return WeakValuedValueIterator(self)
  96.  
  97.     def popitem(self):
  98.         while 1:
  99.             key, wr = self.data.popitem()
  100.             o = wr()
  101.             if o is not None:
  102.                 return key, o
  103.  
  104.     def setdefault(self, key, default):
  105.         try:
  106.             wr = self.data[key]
  107.         except KeyError:
  108.             self.data[key] = ref(default, self.__makeremove(key))
  109.             return default
  110.         else:
  111.             return wr()
  112.  
  113.     def update(self, dict):
  114.         d = self.data
  115.         for key, o in dict.items():
  116.             d[key] = ref(o, self.__makeremove(key))
  117.  
  118.     def values(self):
  119.         L = []
  120.         for wr in self.data.values():
  121.             o = wr()
  122.             if o is not None:
  123.                 L.append(o)
  124.         return L
  125.  
  126.     def __makeremove(self, key):
  127.         def remove(o, selfref=ref(self), key=key):
  128.             self = selfref()
  129.             if self is not None:
  130.                 del self.data[key]
  131.         return remove
  132.  
  133.  
  134. class WeakKeyDictionary(UserDict.UserDict):
  135.     """ Mapping class that references keys weakly.
  136.  
  137.     Entries in the dictionary will be discarded when there is no
  138.     longer a strong reference to the key. This can be used to
  139.     associate additional data with an object owned by other parts of
  140.     an application without adding attributes to those objects. This
  141.     can be especially useful with objects that override attribute
  142.     accesses.
  143.     """
  144.  
  145.     def __init__(self, dict=None):
  146.         self.data = {}
  147.         def remove(k, selfref=ref(self)):
  148.             self = selfref()
  149.             if self is not None:
  150.                 del self.data[k]
  151.         self._remove = remove
  152.         if dict is not None: self.update(dict)
  153.  
  154.     def __delitem__(self, key):
  155.         for ref in self.data.iterkeys():
  156.             o = ref()
  157.             if o == key:
  158.                 del self.data[ref]
  159.                 return
  160.  
  161.     def __getitem__(self, key):
  162.         return self.data[ref(key)]
  163.  
  164.     def __repr__(self):
  165.         return "<WeakKeyDictionary at %s>" % id(self)
  166.  
  167.     def __setitem__(self, key, value):
  168.         self.data[ref(key, self._remove)] = value
  169.  
  170.     def copy(self):
  171.         new = WeakKeyDictionary()
  172.         for key, value in self.data.items():
  173.             o = key()
  174.             if o is not None:
  175.                 new[o] = value
  176.         return new
  177.  
  178.     def get(self, key, default=None):
  179.         return self.data.get(ref(key),default)
  180.  
  181.     def has_key(self, key):
  182.         try:
  183.             wr = ref(key)
  184.         except TypeError:
  185.             return 0
  186.         return self.data.has_key(wr)
  187.  
  188.     def items(self):
  189.         L = []
  190.         for key, value in self.data.items():
  191.             o = key()
  192.             if o is not None:
  193.                 L.append((o, value))
  194.         return L
  195.  
  196.     def iteritems(self):
  197.         return WeakKeyedItemIterator(self)
  198.  
  199.     def iterkeys(self):
  200.         return WeakKeyedKeyIterator(self)
  201.     __iter__ = iterkeys
  202.  
  203.     def itervalues(self):
  204.         return self.data.itervalues()
  205.  
  206.     def keys(self):
  207.         L = []
  208.         for wr in self.data.keys():
  209.             o = wr()
  210.             if o is not None:
  211.                 L.append(o)
  212.         return L
  213.  
  214.     def popitem(self):
  215.         while 1:
  216.             key, value = self.data.popitem()
  217.             o = key()
  218.             if o is not None:
  219.                 return o, value
  220.  
  221.     def setdefault(self, key, default):
  222.         return self.data.setdefault(ref(key, self._remove),default)
  223.  
  224.     def update(self, dict):
  225.         d = self.data
  226.         for key, value in dict.items():
  227.             d[ref(key, self._remove)] = value
  228.  
  229.  
  230. class BaseIter:
  231.     def __iter__(self):
  232.         return self
  233.  
  234.  
  235. class WeakKeyedKeyIterator(BaseIter):
  236.     def __init__(self, weakdict):
  237.         self._next = weakdict.data.iterkeys().next
  238.  
  239.     def next(self):
  240.         while 1:
  241.             wr = self._next()
  242.             obj = wr()
  243.             if obj is not None:
  244.                 return obj
  245.  
  246.  
  247. class WeakKeyedItemIterator(BaseIter):
  248.     def __init__(self, weakdict):
  249.         self._next = weakdict.data.iteritems().next
  250.  
  251.     def next(self):
  252.         while 1:
  253.             wr, value = self._next()
  254.             key = wr()
  255.             if key is not None:
  256.                 return key, value
  257.  
  258.  
  259. class WeakValuedValueIterator(BaseIter):
  260.     def __init__(self, weakdict):
  261.         self._next = weakdict.data.itervalues().next
  262.  
  263.     def next(self):
  264.         while 1:
  265.             wr = self._next()
  266.             obj = wr()
  267.             if obj is not None:
  268.                 return obj
  269.  
  270.  
  271. class WeakValuedItemIterator(BaseIter):
  272.     def __init__(self, weakdict):
  273.         self._next = weakdict.data.iteritems().next
  274.  
  275.     def next(self):
  276.         while 1:
  277.             key, wr = self._next()
  278.             value = wr()
  279.             if value is not None:
  280.                 return key, value
  281.  
  282.  
  283. # no longer needed
  284. del UserDict
  285.